package org.code.boot.service.boot.impl;

import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import cn.hutool.core.collection.CollUtil;
import java.util.stream.Collectors;
import org.code.boot.common.exception.ServiceException;
import org.code.boot.domain.boot.BizTrainOrder;
import org.code.boot.service.boot.IBizTrainOrderService;
import org.code.boot.common.utils.DateUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.code.boot.mapper.boot.BizTrainMapper;
import org.code.boot.domain.boot.BizTrain;
import org.code.boot.service.boot.IBizTrainService;
import org.code.boot.service.boot.IBizTrainSeatConfigService;
import org.code.boot.domain.boot.BizTrainSeatConfig;

/**
 * 火车信息Service业务层处理
 * 
 * @author coder
 * @date 2025-08-28
 */
@Service
public class BizTrainServiceImpl implements IBizTrainService 
{
    @Autowired
    private BizTrainMapper bizTrainMapper;

    @Autowired
    private IBizTrainOrderService bizTrainOrderService;

    @Autowired
    private IBizTrainSeatConfigService bizTrainSeatConfigService;


    /**
     * 查询火车信息
     * 
     * @param trainId 火车信息主键
     * @return 火车信息
     */
    @Override
    public BizTrain selectBizTrainByTrainId(Long trainId)
    {
        BizTrain train = bizTrainMapper.selectBizTrainByTrainId(trainId);
        if (train != null) {
            // 计算总可用座位数
            Integer availableSeats = getTotalAvailableSeats(trainId);
            train.setAvailableSeats(availableSeats);
        }
        return train;
    }

    /**
     * 查询火车信息列表
     * 
     * @param bizTrain 火车信息
     * @return 火车信息
     */
    @Override
    public List<BizTrain> selectBizTrainList(BizTrain bizTrain)
    {
        List<BizTrain> trainList = bizTrainMapper.selectBizTrainList(bizTrain);
        // 为每个火车计算总可用座位数
        trainList.forEach(train -> {
            Integer availableSeats = getTotalAvailableSeats(train.getTrainId());
            train.setAvailableSeats(availableSeats);
        });
        return trainList;
    }

    /**
     * 新增火车信息
     * 
     * @param bizTrain 火车信息
     * @return 结果
     */
    @Override
    public int insertBizTrain(BizTrain bizTrain)
    {
        bizTrain.setCreateTime(DateUtils.getNowDate());
        return bizTrainMapper.insertBizTrain(bizTrain);
    }

    /**
     * 修改火车信息
     * 
     * @param bizTrain 火车信息
     * @return 结果
     */
    @Override
    public int updateBizTrain(BizTrain bizTrain)
    {
        bizTrain.setUpdateTime(DateUtils.getNowDate());
        return bizTrainMapper.updateBizTrain(bizTrain);
    }

    /**
     * 批量删除火车信息
     * 
     * @param trainIds 需要删除的火车信息主键
     * @return 结果
     */
    @Override
    public int deleteBizTrainByTrainIds(Long[] trainIds)
    {
        // 检查数据表是否被其他表引用
        List<Long> idList = Arrays.asList(trainIds);
        if (isDataTableReferenced(idList))
        {
            throw new ServiceException("该火车信息中有数据正在被其他表引用，无法删除");
        }
        return bizTrainMapper.deleteBizTrainByTrainIds(trainIds);
    }

    /**
     * 删除火车信息信息
     * 
     * @param trainId 火车信息主键
     * @return 结果
     */
    @Override
    public int deleteBizTrainByTrainId(Long trainId)
    {
        // 检查数据表是否被其他表引用
        List<Long> idList = Arrays.asList(trainId);
        if (isDataTableReferenced(idList))
        {
            throw new ServiceException("该火车信息正在被其他数据引用，无法删除");
        }
        return bizTrainMapper.deleteBizTrainByTrainId(trainId);
    }
    /**
     * 获得火车信息列表
     *
     * @param ids 火车信息编号数组
     * @return 火车信息列表
     */
    @Override
    public List<BizTrain> getBizTrainList(Collection<Long> ids) {
        if (CollUtil.isEmpty(ids)) {
            return new ArrayList<>();
        }
        return bizTrainMapper.selectBizTrainListByIds(ids);
    }

    
    /**
     * 检查数据表是否被其他表引用
     * 
     * @param ids 火车信息主键列表
     * @return 是否被引用
     */
    private boolean isDataTableReferenced(List<Long> ids) {
        if (CollUtil.isEmpty(ids)) {
            return false;
        }
        
        // 检查引用此数据表的其他表
        // 检查 BizTrainOrder 表中是否有引用当前数据的记录
        Long count1 = bizTrainOrderService.countByTrainIds(ids);
        if (count1 != null && count1 > 0) {
            return true; // BizTrainOrder 表中存在引用记录
        }

        return false;
    }

    /**
     * 计算火车总可用座位数
     * 
     * @param trainId 火车ID
     * @return 总可用座位数
     */
    @Override
    public Integer getTotalAvailableSeats(Long trainId) {
        if (trainId == null) {
            return 0;
        }
        
        List<BizTrainSeatConfig> seatConfigs = bizTrainSeatConfigService.selectBizTrainSeatConfigByTrainId(trainId);
        if (CollUtil.isEmpty(seatConfigs)) {
            return 0;
        }
        
        return seatConfigs.stream()
                .mapToInt(config -> config.getAvailableSeats() != null ? config.getAvailableSeats() : 0)
                .sum();
    }
}
